/*
 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.lang.management;

import javax.management.DynamicMBean;
import javax.management.MBeanServer;
import javax.management.MBeanServerConnection;
import javax.management.MBeanServerFactory;
import javax.management.MBeanServerPermission;
import javax.management.NotificationEmitter;
import javax.management.ObjectInstance;
import javax.management.ObjectName;
import javax.management.InstanceAlreadyExistsException;
import javax.management.InstanceNotFoundException;
import javax.management.MalformedObjectNameException;
import javax.management.MBeanRegistrationException;
import javax.management.NotCompliantMBeanException;
import javax.management.StandardEmitterMBean;
import javax.management.StandardMBean;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.security.AccessController;
import java.security.Permission;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import javax.management.JMX;
import sun.management.ManagementFactoryHelper;
import sun.management.ExtendedPlatformComponent;

/**
 * The {@code ManagementFactory} class is a factory class for getting
 * managed beans for the Java platform.
 * This class consists of static methods each of which returns
 * one or more <i>platform MXBeans</i> representing
 * the management interface of a component of the Java virtual
 * machine.
 *
 * <h3><a name="MXBean">Platform MXBeans</a></h3>
 * <p>
 * A platform MXBean is a <i>managed bean</i> that
 * conforms to the <a href="../../../javax/management/package-summary.html">JMX</a>
 * Instrumentation Specification and only uses a set of basic data types.
 * A JMX management application and the {@linkplain
 * #getPlatformMBeanServer platform MBeanServer}
 * can interoperate without requiring classes for MXBean specific
 * data types.
 * The data types being transmitted between the JMX connector
 * server and the connector client are
 * {@linkplain javax.management.openmbean.OpenType open types}
 * and this allows interoperation across versions.
 * See <a href="../../../javax/management/MXBean.html#MXBean-spec">
 * the specification of MXBeans</a> for details.
 *
 * <a name="MXBeanNames"></a>
 * <p>Each platform MXBean is a {@link PlatformManagedObject}
 * and it has a unique
 * {@link javax.management.ObjectName ObjectName} for
 * registration in the platform {@code MBeanServer} as returned by
 * by the {@link PlatformManagedObject#getObjectName getObjectName}
 * method.
 *
 * <p>
 * An application can access a platform MXBean in the following ways:
 * <h4>1. Direct access to an MXBean interface</h4>
 * <blockquote>
 * <ul>
 * <li>Get an MXBean instance by calling the
 * {@link #getPlatformMXBean(Class) getPlatformMXBean} or
 * {@link #getPlatformMXBeans(Class) getPlatformMXBeans} method
 * and access the MXBean locally in the running
 * virtual machine.
 * </li>
 * <li>Construct an MXBean proxy instance that forwards the
 * method calls to a given {@link MBeanServer MBeanServer} by calling
 * the {@link #getPlatformMXBean(MBeanServerConnection, Class)} or
 * {@link #getPlatformMXBeans(MBeanServerConnection, Class)} method.
 * The {@link #newPlatformMXBeanProxy newPlatformMXBeanProxy} method
 * can also be used to construct an MXBean proxy instance of
 * a given {@code ObjectName}.
 * A proxy is typically constructed to remotely access
 * an MXBean of another running virtual machine.
 * </li>
 * </ul>
 * <h4>2. Indirect access to an MXBean interface via MBeanServer</h4>
 * <ul>
 * <li>Go through the platform {@code MBeanServer} to access MXBeans
 * locally or a specific <tt>MBeanServerConnection</tt> to access
 * MXBeans remotely.
 * The attributes and operations of an MXBean use only
 * <em>JMX open types</em> which include basic data types,
 * {@link javax.management.openmbean.CompositeData CompositeData},
 * and {@link javax.management.openmbean.TabularData TabularData}
 * defined in
 * {@link javax.management.openmbean.OpenType OpenType}.
 * The mapping is specified in
 * the {@linkplain javax.management.MXBean MXBean} specification
 * for details.
 * </li>
 * </ul>
 * </blockquote>
 *
 * <p>
 * The {@link #getPlatformManagementInterfaces getPlatformManagementInterfaces}
 * method returns all management interfaces supported in the Java virtual machine
 * including the standard management interfaces listed in the tables
 * below as well as the management interfaces extended by the JDK implementation.
 * <p>
 * A Java virtual machine has a single instance of the following management
 * interfaces:
 *
 * <blockquote>
 * <table border summary="The list of Management Interfaces and their single instances">
 * <tr>
 * <th>Management Interface</th>
 * <th>ObjectName</th>
 * </tr>
 * <tr>
 * <td> {@link ClassLoadingMXBean} </td>
 * <td> {@link #CLASS_LOADING_MXBEAN_NAME
 * java.lang:type=ClassLoading}</td>
 * </tr>
 * <tr>
 * <td> {@link MemoryMXBean} </td>
 * <td> {@link #MEMORY_MXBEAN_NAME
 * java.lang:type=Memory}</td>
 * </tr>
 * <tr>
 * <td> {@link ThreadMXBean} </td>
 * <td> {@link #THREAD_MXBEAN_NAME
 * java.lang:type=Threading}</td>
 * </tr>
 * <tr>
 * <td> {@link RuntimeMXBean} </td>
 * <td> {@link #RUNTIME_MXBEAN_NAME
 * java.lang:type=Runtime}</td>
 * </tr>
 * <tr>
 * <td> {@link OperatingSystemMXBean} </td>
 * <td> {@link #OPERATING_SYSTEM_MXBEAN_NAME
 * java.lang:type=OperatingSystem}</td>
 * </tr>
 * <tr>
 * <td> {@link PlatformLoggingMXBean} </td>
 * <td> {@link java.util.logging.LogManager#LOGGING_MXBEAN_NAME
 * java.util.logging:type=Logging}</td>
 * </tr>
 * </table>
 * </blockquote>
 *
 * <p>
 * A Java virtual machine has zero or a single instance of
 * the following management interfaces.
 *
 * <blockquote>
 * <table border summary="The list of Management Interfaces and their single instances">
 * <tr>
 * <th>Management Interface</th>
 * <th>ObjectName</th>
 * </tr>
 * <tr>
 * <td> {@link CompilationMXBean} </td>
 * <td> {@link #COMPILATION_MXBEAN_NAME
 * java.lang:type=Compilation}</td>
 * </tr>
 * </table>
 * </blockquote>
 *
 * <p>
 * A Java virtual machine may have one or more instances of the following
 * management interfaces.
 * <blockquote>
 * <table border summary="The list of Management Interfaces and their single instances">
 * <tr>
 * <th>Management Interface</th>
 * <th>ObjectName</th>
 * </tr>
 * <tr>
 * <td> {@link GarbageCollectorMXBean} </td>
 * <td> {@link #GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE
 * java.lang:type=GarbageCollector}<tt>,name=</tt><i>collector's name</i></td>
 * </tr>
 * <tr>
 * <td> {@link MemoryManagerMXBean} </td>
 * <td> {@link #MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE
 * java.lang:type=MemoryManager}<tt>,name=</tt><i>manager's name</i></td>
 * </tr>
 * <tr>
 * <td> {@link MemoryPoolMXBean} </td>
 * <td> {@link #MEMORY_POOL_MXBEAN_DOMAIN_TYPE
 * java.lang:type=MemoryPool}<tt>,name=</tt><i>pool's name</i></td>
 * </tr>
 * <tr>
 * <td> {@link BufferPoolMXBean} </td>
 * <td> {@code java.nio:type=BufferPool,name=}<i>pool name</i></td>
 * </tr>
 * </table>
 * </blockquote>
 *
 * @author Mandy Chung
 * @see <a href="../../../javax/management/package-summary.html"> JMX Specification</a>
 * @see <a href="package-summary.html#examples"> Ways to Access Management Metrics</a>
 * @see javax.management.MXBean
 * @since 1.5
 */
public class ManagementFactory {

  // A class with only static fields and methods.
  private ManagementFactory() {
  }

  ;

  /**
   * String representation of the
   * <tt>ObjectName</tt> for the {@link ClassLoadingMXBean}.
   */
  public final static String CLASS_LOADING_MXBEAN_NAME =
      "java.lang:type=ClassLoading";

  /**
   * String representation of the
   * <tt>ObjectName</tt> for the {@link CompilationMXBean}.
   */
  public final static String COMPILATION_MXBEAN_NAME =
      "java.lang:type=Compilation";

  /**
   * String representation of the
   * <tt>ObjectName</tt> for the {@link MemoryMXBean}.
   */
  public final static String MEMORY_MXBEAN_NAME =
      "java.lang:type=Memory";

  /**
   * String representation of the
   * <tt>ObjectName</tt> for the {@link OperatingSystemMXBean}.
   */
  public final static String OPERATING_SYSTEM_MXBEAN_NAME =
      "java.lang:type=OperatingSystem";

  /**
   * String representation of the
   * <tt>ObjectName</tt> for the {@link RuntimeMXBean}.
   */
  public final static String RUNTIME_MXBEAN_NAME =
      "java.lang:type=Runtime";

  /**
   * String representation of the
   * <tt>ObjectName</tt> for the {@link ThreadMXBean}.
   */
  public final static String THREAD_MXBEAN_NAME =
      "java.lang:type=Threading";

  /**
   * The domain name and the type key property in
   * the <tt>ObjectName</tt> for a {@link GarbageCollectorMXBean}.
   * The unique <tt>ObjectName</tt> for a <tt>GarbageCollectorMXBean</tt>
   * can be formed by appending this string with
   * "<tt>,name=</tt><i>collector's name</i>".
   */
  public final static String GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE =
      "java.lang:type=GarbageCollector";

  /**
   * The domain name and the type key property in
   * the <tt>ObjectName</tt> for a {@link MemoryManagerMXBean}.
   * The unique <tt>ObjectName</tt> for a <tt>MemoryManagerMXBean</tt>
   * can be formed by appending this string with
   * "<tt>,name=</tt><i>manager's name</i>".
   */
  public final static String MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE =
      "java.lang:type=MemoryManager";

  /**
   * The domain name and the type key property in
   * the <tt>ObjectName</tt> for a {@link MemoryPoolMXBean}.
   * The unique <tt>ObjectName</tt> for a <tt>MemoryPoolMXBean</tt>
   * can be formed by appending this string with
   * <tt>,name=</tt><i>pool's name</i>.
   */
  public final static String MEMORY_POOL_MXBEAN_DOMAIN_TYPE =
      "java.lang:type=MemoryPool";

  /**
   * Returns the managed bean for the class loading system of
   * the Java virtual machine.
   *
   * @return a {@link ClassLoadingMXBean} object for the Java virtual machine.
   */
  public static ClassLoadingMXBean getClassLoadingMXBean() {
    return ManagementFactoryHelper.getClassLoadingMXBean();
  }

  /**
   * Returns the managed bean for the memory system of
   * the Java virtual machine.
   *
   * @return a {@link MemoryMXBean} object for the Java virtual machine.
   */
  public static MemoryMXBean getMemoryMXBean() {
    return ManagementFactoryHelper.getMemoryMXBean();
  }

  /**
   * Returns the managed bean for the thread system of
   * the Java virtual machine.
   *
   * @return a {@link ThreadMXBean} object for the Java virtual machine.
   */
  public static ThreadMXBean getThreadMXBean() {
    return ManagementFactoryHelper.getThreadMXBean();
  }

  /**
   * Returns the managed bean for the runtime system of
   * the Java virtual machine.
   *
   * @return a {@link RuntimeMXBean} object for the Java virtual machine.
   */
  public static RuntimeMXBean getRuntimeMXBean() {
    return ManagementFactoryHelper.getRuntimeMXBean();
  }

  /**
   * Returns the managed bean for the compilation system of
   * the Java virtual machine.  This method returns <tt>null</tt>
   * if the Java virtual machine has no compilation system.
   *
   * @return a {@link CompilationMXBean} object for the Java virtual machine or <tt>null</tt> if the
   * Java virtual machine has no compilation system.
   */
  public static CompilationMXBean getCompilationMXBean() {
    return ManagementFactoryHelper.getCompilationMXBean();
  }

  /**
   * Returns the managed bean for the operating system on which
   * the Java virtual machine is running.
   *
   * @return an {@link OperatingSystemMXBean} object for the Java virtual machine.
   */
  public static OperatingSystemMXBean getOperatingSystemMXBean() {
    return ManagementFactoryHelper.getOperatingSystemMXBean();
  }

  /**
   * Returns a list of {@link MemoryPoolMXBean} objects in the
   * Java virtual machine.
   * The Java virtual machine can have one or more memory pools.
   * It may add or remove memory pools during execution.
   *
   * @return a list of <tt>MemoryPoolMXBean</tt> objects.
   */
  public static List<MemoryPoolMXBean> getMemoryPoolMXBeans() {
    return ManagementFactoryHelper.getMemoryPoolMXBeans();
  }

  /**
   * Returns a list of {@link MemoryManagerMXBean} objects
   * in the Java virtual machine.
   * The Java virtual machine can have one or more memory managers.
   * It may add or remove memory managers during execution.
   *
   * @return a list of <tt>MemoryManagerMXBean</tt> objects.
   */
  public static List<MemoryManagerMXBean> getMemoryManagerMXBeans() {
    return ManagementFactoryHelper.getMemoryManagerMXBeans();
  }


  /**
   * Returns a list of {@link GarbageCollectorMXBean} objects
   * in the Java virtual machine.
   * The Java virtual machine may have one or more
   * <tt>GarbageCollectorMXBean</tt> objects.
   * It may add or remove <tt>GarbageCollectorMXBean</tt>
   * during execution.
   *
   * @return a list of <tt>GarbageCollectorMXBean</tt> objects.
   */
  public static List<GarbageCollectorMXBean> getGarbageCollectorMXBeans() {
    return ManagementFactoryHelper.getGarbageCollectorMXBeans();
  }

  private static MBeanServer platformMBeanServer;

  /**
   * Returns the platform {@link javax.management.MBeanServer MBeanServer}.
   * On the first call to this method, it first creates the platform
   * {@code MBeanServer} by calling the
   * {@link javax.management.MBeanServerFactory#createMBeanServer
   * MBeanServerFactory.createMBeanServer}
   * method and registers each platform MXBean in this platform
   * {@code MBeanServer} with its
   * {@link PlatformManagedObject#getObjectName ObjectName}.
   * This method, in subsequent calls, will simply return the
   * initially created platform {@code MBeanServer}.
   * <p>
   * MXBeans that get created and destroyed dynamically, for example,
   * memory {@link MemoryPoolMXBean pools} and
   * {@link MemoryManagerMXBean managers},
   * will automatically be registered and deregistered into the platform
   * {@code MBeanServer}.
   * <p>
   * If the system property {@code javax.management.builder.initial}
   * is set, the platform {@code MBeanServer} creation will be done
   * by the specified {@link javax.management.MBeanServerBuilder}.
   * <p>
   * It is recommended that this platform MBeanServer also be used
   * to register other application managed beans
   * besides the platform MXBeans.
   * This will allow all MBeans to be published through the same
   * {@code MBeanServer} and hence allow for easier network publishing
   * and discovery.
   * Name conflicts with the platform MXBeans should be avoided.
   *
   * @return the platform {@code MBeanServer}; the platform MXBeans are registered into the platform
   * {@code MBeanServer} at the first time this method is called.
   * @throws SecurityException if there is a security manager and the caller does not have the
   * permission required by {@link javax.management.MBeanServerFactory#createMBeanServer}.
   * @see javax.management.MBeanServerFactory
   * @see javax.management.MBeanServerFactory#createMBeanServer
   */
  public static synchronized MBeanServer getPlatformMBeanServer() {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
      Permission perm = new MBeanServerPermission("createMBeanServer");
      sm.checkPermission(perm);
    }

    if (platformMBeanServer == null) {
      platformMBeanServer = MBeanServerFactory.createMBeanServer();
      for (PlatformComponent pc : PlatformComponent.values()) {
        List<? extends PlatformManagedObject> list =
            pc.getMXBeans(pc.getMXBeanInterface());
        for (PlatformManagedObject o : list) {
          // Each PlatformComponent represents one management
          // interface. Some MXBean may extend another one.
          // The MXBean instances for one platform component
          // (returned by pc.getMXBeans()) might be also
          // the MXBean instances for another platform component.
          // e.g. com.sun.management.GarbageCollectorMXBean
          //
          // So need to check if an MXBean instance is registered
          // before registering into the platform MBeanServer
          if (!platformMBeanServer.isRegistered(o.getObjectName())) {
            addMXBean(platformMBeanServer, o);
          }
        }
      }
      HashMap<ObjectName, DynamicMBean> dynmbeans =
          ManagementFactoryHelper.getPlatformDynamicMBeans();
      for (Map.Entry<ObjectName, DynamicMBean> e : dynmbeans.entrySet()) {
        addDynamicMBean(platformMBeanServer, e.getValue(), e.getKey());
      }
      for (final PlatformManagedObject o :
          ExtendedPlatformComponent.getMXBeans()) {
        if (!platformMBeanServer.isRegistered(o.getObjectName())) {
          addMXBean(platformMBeanServer, o);
        }
      }
    }
    return platformMBeanServer;
  }

  /**
   * Returns a proxy for a platform MXBean interface of a
   * given <a href="#MXBeanNames">MXBean name</a>
   * that forwards its method calls through the given
   * <tt>MBeanServerConnection</tt>.
   *
   * <p>This method is equivalent to:
   * <blockquote>
   * {@link java.lang.reflect.Proxy#newProxyInstance
   * Proxy.newProxyInstance}<tt>(mxbeanInterface.getClassLoader(),
   * new Class[] { mxbeanInterface }, handler)</tt>
   * </blockquote>
   *
   * where <tt>handler</tt> is an {@link java.lang.reflect.InvocationHandler
   * InvocationHandler} to which method invocations to the MXBean interface
   * are dispatched. This <tt>handler</tt> converts an input parameter
   * from an MXBean data type to its mapped open type before forwarding
   * to the <tt>MBeanServer</tt> and converts a return value from
   * an MXBean method call through the <tt>MBeanServer</tt>
   * from an open type to the corresponding return type declared in
   * the MXBean interface.
   *
   * <p>
   * If the MXBean is a notification emitter (i.e.,
   * it implements
   * {@link javax.management.NotificationEmitter NotificationEmitter}),
   * both the <tt>mxbeanInterface</tt> and <tt>NotificationEmitter</tt>
   * will be implemented by this proxy.
   *
   * <p>
   * <b>Notes:</b>
   * <ol>
   * <li>Using an MXBean proxy is a convenience remote access to
   * a platform MXBean of a running virtual machine.  All method
   * calls to the MXBean proxy are forwarded to an
   * <tt>MBeanServerConnection</tt> where
   * {@link java.io.IOException IOException} may be thrown
   * when the communication problem occurs with the connector server.
   * An application remotely accesses the platform MXBeans using
   * proxy should prepare to catch <tt>IOException</tt> as if
   * accessing with the <tt>MBeanServerConnector</tt> interface.</li>
   *
   * <li>When a client application is designed to remotely access MXBeans
   * for a running virtual machine whose version is different than
   * the version on which the application is running,
   * it should prepare to catch
   * {@link java.io.InvalidObjectException InvalidObjectException}
   * which is thrown when an MXBean proxy receives a name of an
   * enum constant which is missing in the enum class loaded in
   * the client application. </li>
   *
   * <li>{@link javax.management.MBeanServerInvocationHandler
   * MBeanServerInvocationHandler} or its
   * {@link javax.management.MBeanServerInvocationHandler#newProxyInstance
   * newProxyInstance} method cannot be used to create
   * a proxy for a platform MXBean. The proxy object created
   * by <tt>MBeanServerInvocationHandler</tt> does not handle
   * the properties of the platform MXBeans described in
   * the <a href="#MXBean">class specification</a>.
   * </li>
   * </ol>
   *
   * @param connection the <tt>MBeanServerConnection</tt> to forward to.
   * @param mxbeanName the name of a platform MXBean within <tt>connection</tt> to forward to.
   * <tt>mxbeanName</tt> must be in the format of {@link ObjectName ObjectName}.
   * @param mxbeanInterface the MXBean interface to be implemented by the proxy.
   * @param <T> an {@code mxbeanInterface} type parameter
   * @return a proxy for a platform MXBean interface of a given <a href="#MXBeanNames">MXBean
   * name</a> that forwards its method calls through the given <tt>MBeanServerConnection</tt>, or
   * {@code null} if not exist.
   * @throws IllegalArgumentException if <ul> <li><tt>mxbeanName</tt> is not with a valid {@link
   * ObjectName ObjectName} format, or</li> <li>the named MXBean in the <tt>connection</tt> is not a
   * MXBean provided by the platform, or</li> <li>the named MXBean is not registered in the
   * <tt>MBeanServerConnection</tt>, or</li> <li>the named MXBean is not an instance of the given
   * <tt>mxbeanInterface</tt></li> </ul>
   * @throws java.io.IOException if a communication problem occurred when accessing the
   * <tt>MBeanServerConnection</tt>.
   */
  public static <T> T
  newPlatformMXBeanProxy(MBeanServerConnection connection,
      String mxbeanName,
      Class<T> mxbeanInterface)
      throws java.io.IOException {

    // Only allow MXBean interfaces from rt.jar loaded by the
    // bootstrap class loader
    final Class<?> cls = mxbeanInterface;
    ClassLoader loader =
        AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
          public ClassLoader run() {
            return cls.getClassLoader();
          }
        });
    if (!sun.misc.VM.isSystemDomainLoader(loader)) {
      throw new IllegalArgumentException(mxbeanName +
          " is not a platform MXBean");
    }

    try {
      final ObjectName objName = new ObjectName(mxbeanName);
      // skip the isInstanceOf check for LoggingMXBean
      String intfName = mxbeanInterface.getName();
      if (!connection.isInstanceOf(objName, intfName)) {
        throw new IllegalArgumentException(mxbeanName +
            " is not an instance of " + mxbeanInterface);
      }

      final Class[] interfaces;
      // check if the registered MBean is a notification emitter
      boolean emitter = connection.isInstanceOf(objName, NOTIF_EMITTER);

      // create an MXBean proxy
      return JMX.newMXBeanProxy(connection, objName, mxbeanInterface,
          emitter);
    } catch (InstanceNotFoundException | MalformedObjectNameException e) {
      throw new IllegalArgumentException(e);
    }
  }

  /**
   * Returns the platform MXBean implementing
   * the given {@code mxbeanInterface} which is specified
   * to have one single instance in the Java virtual machine.
   * This method may return {@code null} if the management interface
   * is not implemented in the Java virtual machine (for example,
   * a Java virtual machine with no compilation system does not
   * implement {@link CompilationMXBean});
   * otherwise, this method is equivalent to calling:
   * <pre>
   *    {@link #getPlatformMXBeans(Class)
   *      getPlatformMXBeans(mxbeanInterface)}.get(0);
   * </pre>
   *
   * @param mxbeanInterface a management interface for a platform MXBean with one single instance in
   * the Java virtual machine if implemented.
   * @param <T> an {@code mxbeanInterface} type parameter
   * @return the platform MXBean that implements {@code mxbeanInterface}, or {@code null} if not
   * exist.
   * @throws IllegalArgumentException if {@code mxbeanInterface} is not a platform management
   * interface or not a singleton platform MXBean.
   * @since 1.7
   */
  public static <T extends PlatformManagedObject>
  T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
      T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
      if (mbean != null) {
        return mbean;
      }
      throw new IllegalArgumentException(mxbeanInterface.getName() +
          " is not a platform management interface");
    }
    if (!pc.isSingleton()) {
      throw new IllegalArgumentException(mxbeanInterface.getName() +
          " can have zero or more than one instances");
    }

    return pc.getSingletonMXBean(mxbeanInterface);
  }

  /**
   * Returns the list of platform MXBeans implementing
   * the given {@code mxbeanInterface} in the Java
   * virtual machine.
   * The returned list may contain zero, one, or more instances.
   * The number of instances in the returned list is defined
   * in the specification of the given management interface.
   * The order is undefined and there is no guarantee that
   * the list returned is in the same order as previous invocations.
   *
   * @param mxbeanInterface a management interface for a platform MXBean
   * @param <T> an {@code mxbeanInterface} type parameter
   * @return the list of platform MXBeans that implement {@code mxbeanInterface}.
   * @throws IllegalArgumentException if {@code mxbeanInterface} is not a platform management
   * interface.
   * @since 1.7
   */
  public static <T extends PlatformManagedObject> List<T>
  getPlatformMXBeans(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
      T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
      if (mbean != null) {
        return Collections.singletonList(mbean);
      }
      throw new IllegalArgumentException(mxbeanInterface.getName() +
          " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(mxbeanInterface));
  }

  /**
   * Returns the platform MXBean proxy for
   * {@code mxbeanInterface} which is specified to have one single
   * instance in a Java virtual machine and the proxy will
   * forward the method calls through the given {@code MBeanServerConnection}.
   * This method may return {@code null} if the management interface
   * is not implemented in the Java virtual machine being monitored
   * (for example, a Java virtual machine with no compilation system
   * does not implement {@link CompilationMXBean});
   * otherwise, this method is equivalent to calling:
   * <pre>
   *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
   *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
   * </pre>
   *
   * @param connection the {@code MBeanServerConnection} to forward to.
   * @param mxbeanInterface a management interface for a platform MXBean with one single instance in
   * the Java virtual machine being monitored, if implemented.
   * @param <T> an {@code mxbeanInterface} type parameter
   * @return the platform MXBean proxy for forwarding the method calls of the {@code
   * mxbeanInterface} through the given {@code MBeanServerConnection}, or {@code null} if not
   * exist.
   * @throws IllegalArgumentException if {@code mxbeanInterface} is not a platform management
   * interface or not a singleton platform MXBean.
   * @throws java.io.IOException if a communication problem occurred when accessing the {@code
   * MBeanServerConnection}.
   * @see #newPlatformMXBeanProxy
   * @since 1.7
   */
  public static <T extends PlatformManagedObject>
  T getPlatformMXBean(MBeanServerConnection connection,
      Class<T> mxbeanInterface)
      throws java.io.IOException {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
      T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
      if (mbean != null) {
        ObjectName on = mbean.getObjectName();
        return ManagementFactory.newPlatformMXBeanProxy(connection,
            on.getCanonicalName(),
            mxbeanInterface);
      }
      throw new IllegalArgumentException(mxbeanInterface.getName() +
          " is not a platform management interface");
    }
    if (!pc.isSingleton()) {
      throw new IllegalArgumentException(mxbeanInterface.getName() +
          " can have zero or more than one instances");
    }
    return pc.getSingletonMXBean(connection, mxbeanInterface);
  }

  /**
   * Returns the list of the platform MXBean proxies for
   * forwarding the method calls of the {@code mxbeanInterface}
   * through the given {@code MBeanServerConnection}.
   * The returned list may contain zero, one, or more instances.
   * The number of instances in the returned list is defined
   * in the specification of the given management interface.
   * The order is undefined and there is no guarantee that
   * the list returned is in the same order as previous invocations.
   *
   * @param connection the {@code MBeanServerConnection} to forward to.
   * @param mxbeanInterface a management interface for a platform MXBean
   * @param <T> an {@code mxbeanInterface} type parameter
   * @return the list of platform MXBean proxies for forwarding the method calls of the {@code
   * mxbeanInterface} through the given {@code MBeanServerConnection}.
   * @throws IllegalArgumentException if {@code mxbeanInterface} is not a platform management
   * interface.
   * @throws java.io.IOException if a communication problem occurred when accessing the {@code
   * MBeanServerConnection}.
   * @see #newPlatformMXBeanProxy
   * @since 1.7
   */
  public static <T extends PlatformManagedObject>
  List<T> getPlatformMXBeans(MBeanServerConnection connection,
      Class<T> mxbeanInterface)
      throws java.io.IOException {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
      T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
      if (mbean != null) {
        ObjectName on = mbean.getObjectName();
        T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
            on.getCanonicalName(), mxbeanInterface);
        return Collections.singletonList(proxy);
      }
      throw new IllegalArgumentException(mxbeanInterface.getName() +
          " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
  }

  /**
   * Returns the set of {@code Class} objects, subinterface of
   * {@link PlatformManagedObject}, representing
   * all management interfaces for
   * monitoring and managing the Java platform.
   *
   * @return the set of {@code Class} objects, subinterface of {@link PlatformManagedObject}
   * representing the management interfaces for monitoring and managing the Java platform.
   * @since 1.7
   */
  public static Set<Class<? extends PlatformManagedObject>>
  getPlatformManagementInterfaces() {
    Set<Class<? extends PlatformManagedObject>> result =
        new HashSet<>();
    for (PlatformComponent component : PlatformComponent.values()) {
      result.add(component.getMXBeanInterface());
    }
    return Collections.unmodifiableSet(result);
  }

  private static final String NOTIF_EMITTER =
      "javax.management.NotificationEmitter";

  /**
   * Registers an MXBean.
   */
  private static void addMXBean(final MBeanServer mbs, final PlatformManagedObject pmo) {
    // Make DynamicMBean out of MXBean by wrapping it with a StandardMBean
    try {
      AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
        public Void run() throws InstanceAlreadyExistsException,
            MBeanRegistrationException,
            NotCompliantMBeanException {
          final DynamicMBean dmbean;
          if (pmo instanceof DynamicMBean) {
            dmbean = DynamicMBean.class.cast(pmo);
          } else if (pmo instanceof NotificationEmitter) {
            dmbean = new StandardEmitterMBean(pmo, null, true, (NotificationEmitter) pmo);
          } else {
            dmbean = new StandardMBean(pmo, null, true);
          }

          mbs.registerMBean(dmbean, pmo.getObjectName());
          return null;
        }
      });
    } catch (PrivilegedActionException e) {
      throw new RuntimeException(e.getException());
    }
  }

  /**
   * Registers a DynamicMBean.
   */
  private static void addDynamicMBean(final MBeanServer mbs,
      final DynamicMBean dmbean,
      final ObjectName on) {
    try {
      AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
        @Override
        public Void run() throws InstanceAlreadyExistsException,
            MBeanRegistrationException,
            NotCompliantMBeanException {
          mbs.registerMBean(dmbean, on);
          return null;
        }
      });
    } catch (PrivilegedActionException e) {
      throw new RuntimeException(e.getException());
    }
  }
}
